#pragma once

#include "ilogger.hpp"
#include "core/blocking_queue.hpp"
#include "core/log_entry.hpp" 
#include <string>
#include <memory>
#include <vector>
#include <chrono>
#include <nlohmann/json.hpp> 
#include <concurrentqueue.h>
#include <deque> // 用于环形缓冲区
#include <mutex>
#include <atomic>

namespace LoggerConstants {
    // 队列相关常量
    constexpr size_t DEFAULT_MAIN_QUEUE_SIZE = 1024 * 1024;  // 1MB
    constexpr size_t DEFAULT_FALLBACK_QUEUE_SIZE = 1024 * 1024;  // 1MB
    constexpr size_t DEFAULT_BATCH_CAPACITY = 10000;
    
    // 时间相关常量
    constexpr auto DEFAULT_FLUSH_INTERVAL = std::chrono::milliseconds(100);
    
    // 文件相关常量
    constexpr size_t DEFAULT_MAX_FILE_SIZE = 1024 * 1024;  // 1MB
    constexpr size_t DEFAULT_MAX_FILES = 5;
    
    // 回溯相关常量
    constexpr size_t DEFAULT_BACKTRACE_SIZE = 100;
    
    // 网络相关常量
    constexpr long DEFAULT_NETWORK_TIMEOUT = 5L;
    constexpr long DEFAULT_CONNECT_TIMEOUT = 2L;
    
    // 内部使用的阈值常量
    constexpr float DEFAULT_QUEUE_SPACE_THRESHOLD = 0.5f;
    constexpr size_t DEFAULT_FALLBACK_BATCH_SIZE = 100;
    constexpr size_t MAX_ITERATIONS = 100000;  // 防止无限循环
}


// --- 前置声明 ---
class AsyncWorker;
// struct LogEntry;

// 抽象基类：格式化器接口 （IFormatter）
class IFormatter {
public:
    virtual ~IFormatter() = default;
    // 将日志级别和消息格式化成字符串
    // 修改：将日志级别和消息格式化成字符串，直接整个接收LogEntry  
    virtual std::string format(const LogEntry& entry) const = 0;
    virtual std::string getName() = 0;
};


// 抽象基类：输出器接口 (ISink)
class ISink {
public:
    virtual ~ISink() = default;
    // 将格式化后的日志消息输出到特定目标
    virtual void log(LogLevel level, const std::string& formatted_message) = 0;
    virtual std::string getName() = 0;
};


// 日志核心类（Logger）- 单例模式
// 单例已成过去式，现在迎接我们的是工厂模式，且保留单例形式兼容之前代码
class Logger final : public ILogger {
public:
    // 公开构造函数，接收所有依赖项
    Logger(std::shared_ptr<IFormatter> formatter,             // 格式器
           const std::vector<std::shared_ptr<ISink>>& sinks,  // 输出器
           size_t main_queue_size,                            // 主队列大小
           size_t fallback_queue_size,                        // 副队列大小
           std::chrono::milliseconds flush_interval);         // 缓冲区强制刷新时间间隔

    // 析构函数负责资源清理
    ~Logger();

    // 禁止拷贝和移动，Logger实例由智能指针管理
    Logger(const Logger&) = delete;
    Logger& operator=(const Logger&) = delete;
    Logger(Logger&&) = delete;
    Logger& operator=(Logger&&) = delete;

    // --- 实现ILogger 接口---
    void setLevel(LogLevel level) override;

    // 判断当前级别是否应该被记录
    bool shouldLog(LogLevel level) const override;

    // 返回格式器名称
    std::string getFormatterType() override;

    // 主要使用接口
    void log(LogLevel level, const std::string& message, const nlohmann::json& context = nlohmann::json()) override;

    // 设置日志回溯缓冲区大小
    void enableBacktrace(size_t size) override;
    // 打印回溯日志
    void dumpBacktrace() override;
    // 刷新缓存种日志的方法
    void flush() override;

    void trace(const std::string& message, const nlohmann::json& context = nlohmann::json()) override;
    void debug(const std::string& message, const nlohmann::json& context = nlohmann::json()) override;
    void info(const std::string& message, const nlohmann::json& context = nlohmann::json()) override;
    void warn(const std::string& message, const nlohmann::json& context = nlohmann::json()) override;
    void error(const std::string& message, const nlohmann::json& context = nlohmann::json()) override;
    void critical(const std::string& message, const nlohmann::json& context = nlohmann::json()) override;

private:
    // 移除了static 成员
    std::vector<std::shared_ptr<ISink>> m_sinks;
    std::shared_ptr<IFormatter> m_formatter;
    //LogLevel m_currentLevel;
    std::atomic<LogLevel> m_currentLevel;

    // --- 日志队列 ---
    std::unique_ptr<moodycamel::ConcurrentQueue<LogEntry>> m_mainQueue;
    std::unique_ptr<BlockingQueue<LogEntry>> m_fallbackQueue;

    std::unique_ptr<AsyncWorker> m_asyncWorker;  // 异步工作线程实例
    
    // 日志回溯缓冲区
    std::deque<LogEntry> m_backtraceBuffer;
    size_t m_backtraceBufferSize = 0;
    bool m_backtraceEnabled = false;
    mutable std::mutex m_backtraceMutex; // mutable允许在const方法中修改

    void handle_backtrace(const LogEntry& entry);
    void enqueue_log(LogEntry&& entry);
    void log_sync(const LogEntry& entry);
};


// --- 宏版本 A: 用于格式化日志 (无独立上下文) ---
// 它在内部调用 fmt::format，并传递一个空的json对象作为上下文
#define LOG_INSTANCE_TRACE(logger_ptr, fmt_str, ...)    (logger_ptr)->trace(fmt::format(FMT_STRING(fmt_str), ##__VA_ARGS__), nlohmann::json())
#define LOG_INSTANCE_DEBUG(logger_ptr, fmt_str, ...)    (logger_ptr)->debug(fmt::format(FMT_STRING(fmt_str), ##__VA_ARGS__), nlohmann::json())
#define LOG_INSTANCE_INFO(logger_ptr, fmt_str, ...)     (logger_ptr)->info(fmt::format(FMT_STRING(fmt_str), ##__VA_ARGS__), nlohmann::json())
#define LOG_INSTANCE_WARN(logger_ptr, fmt_str, ...)     (logger_ptr)->warn(fmt::format(FMT_STRING(fmt_str), ##__VA_ARGS__), nlohmann::json())
#define LOG_INSTANCE_ERROR(logger_ptr, fmt_str, ...)    (logger_ptr)->error(fmt::format(FMT_STRING(fmt_str), ##__VA_ARGS__), nlohmann::json())
#define LOG_INSTANCE_CRITICAL(logger_ptr, fmt_str, ...) (logger_ptr)->critical(fmt::format(FMT_STRING(fmt_str), ##__VA_ARGS__), nlohmann::json())

// --- 宏版本 B: 用于传递独立的JSON上下文 (无格式化) ---
#define LOG_INSTANCE_TRACE_CTX(logger_ptr, msg, ctx)    (logger_ptr)->trace(msg, ctx)
#define LOG_INSTANCE_DEBUG_CTX(logger_ptr, msg, ctx)    (logger_ptr)->debug(msg, ctx)
#define LOG_INSTANCE_INFO_CTX(logger_ptr, msg, ctx)     (logger_ptr)->info(msg, ctx)
#define LOG_INSTANCE_WARN_CTX(logger_ptr, msg, ctx)     (logger_ptr)->warn(msg, ctx)
#define LOG_INSTANCE_ERROR_CTX(logger_ptr, msg, ctx)    (logger_ptr)->error(msg, ctx)
#define LOG_INSTANCE_CRITICAL_CTX(logger_ptr, msg, ctx) (logger_ptr)->critical(msg, ctx)

// --- 同样为全局共享的 Logger 提供两套宏 ---

// 格式化版本
#define LOG_SHARED_TRACE(fmt_str, ...)    LOG_INSTANCE_TRACE(LoggerFactory::getShared(), fmt_str, ##__VA_ARGS__)
#define LOG_SHARED_DEBUG(fmt_str, ...)    LOG_INSTANCE_DEBUG(LoggerFactory::getShared(), fmt_str, ##__VA_ARGS__)
#define LOG_SHARED_INFO(fmt_str, ...)     LOG_INSTANCE_INFO(LoggerFactory::getShared(), fmt_str, ##__VA_ARGS__)
#define LOG_SHARED_WARN(fmt_str, ...)     LOG_INSTANCE_WARN(LoggerFactory::getShared(), fmt_str, ##__VA_ARGS__)
#define LOG_SHARED_ERROR(fmt_str, ...)    LOG_INSTANCE_ERROR(LoggerFactory::getShared(), fmt_str, ##__VA_ARGS__)
#define LOG_SHARED_CRITICAL(fmt_str, ...) LOG_INSTANCE_CRITICAL(LoggerFactory::getShared(), fmt_str, ##__VA_ARGS__)

// 上下文版本
#define LOG_SHARED_TRACE_CTX(msg, ctx)    LOG_INSTANCE_TRACE_CTX(LoggerFactory::getShared(), msg, ctx)
#define LOG_SHARED_DEBUG_CTX(msg, ctx)    LOG_INSTANCE_DEBUG_CTX(LoggerFactory::getShared(), msg, ctx)
#define LOG_SHARED_INFO_CTX(msg, ctx)     LOG_INSTANCE_INFO_CTX(LoggerFactory::getShared(), msg, ctx)
#define LOG_SHARED_WARN_CTX(msg, ctx)     LOG_INSTANCE_WARN_CTX(LoggerFactory::getShared(), msg, ctx)
#define LOG_SHARED_ERROR_CTX(msg, ctx)    LOG_INSTANCE_ERROR_CTX(LoggerFactory::getShared(), msg, ctx)
#define LOG_SHARED_CRITICAL_CTX(msg, ctx) LOG_INSTANCE_CRITICAL_CTX(LoggerFactory::getShared(), msg, ctx)
